{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network implementation (DQN) - with Prioritized Replay (PyTorch).\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**.\n",
    "$$ \\DeclareMathOperator*{\\max}{max}$$\n",
    "### Recap\n",
    "\n",
    "In this notebook, we will implement DQN with **experience replay** and **target networks**.\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla \\hat{q}_{w_t}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/ \n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-29 13:08:26.728670: I tensorflow/core/util/port.cc:111] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-11-29 13:08:26.737494: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-29 13:08:26.881937: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-11-29 13:08:26.882012: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-11-29 13:08:26.882194: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-11-29 13:08:26.930530: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-29 13:08:26.932732: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-29 13:08:28.041427: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole . You may extend it to other environments like Atari games and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=42\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden layers with Relu activation and final layer being logits with dimension equal to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 192))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(192, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, 64))\n",
    "        self.network.add_module('relu3', nn.ReLU())\n",
    "        self.network.add_module('layer4', nn.Linear(64, n_actions))\n",
    "        # \n",
    "        self.parameters = self.network.parameters\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DQNAgent(\n",
       "  (network): Sequential(\n",
       "    (layer1): Linear(in_features=4, out_features=192, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (layer2): Linear(in_features=192, out_features=256, bias=True)\n",
       "    (relu2): ReLU()\n",
       "    (layer3): Linear(in_features=256, out_features=64, bias=True)\n",
       "    (relu3): ReLU()\n",
       "    (layer4): Linear(in_features=64, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for i in range(n_games):\n",
    "        s,_ = env.reset(seed=seed+i)\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1692/1978937824.py:30: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:261.)\n",
      "  states = torch.tensor(states, device=device, dtype=torch.float32)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prioritized Experience replay\n",
    "\n",
    "In this notebook, we will use `Prioritized` version of replay buffer as explained in the paper https://arxiv.org/pdf/1511.05952.pdf. \n",
    "\n",
    "Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "We will be using prioritized version of experience replay. \n",
    "\n",
    "The interface to PrioritizedReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves `(s,a,r,s',done)` tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `update_priorities(idxs, new_priorities)` - returns nothing. \n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "In usual replay buffer, we select training batch with equal probability of selection for each sample/transition stored in the buffer. However, in Prioritized replay, we assign an importance score $p_i$ to each sample/transition. One approach to importance score is to use the absolute value of TD error $\\delta_i$. A small constant $\\epsilon$ is added to avoid the edge case of error being zero and not picked up again ever.  \n",
    "\n",
    "$$ p_i = |\\delta_i| +\\epsilon$$\n",
    "\n",
    "$$\\delta_i = r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "At the time of picking the batch samples from buffer, the individual importance scores for samples are converted to probability which defines the probability of a sample being picked:\n",
    "\n",
    "$$P(i) = \\frac{p_i^{\\alpha}}{\\sum_i p_i^{\\alpha}}; \\alpha=0.6 $$\n",
    "\n",
    "$\\alpha$ is a hyperparameter and in the paper cited above, a value of 0.6 was found to work the best. We are using the same value in our code below:\n",
    "\n",
    "TD error for the samples chosen in the batch is used to calculate the loss and $\\nabla_w(L)$. The TD error is also used to update the importance score $p_i$ of the samples back in the buffer. \n",
    "\n",
    "\n",
    "The probability $P(i)$ is also used to calculate a weight, an importance sampling value, to adjust for the fact that samples now have a non uniform probability of being picked. The weight vector for batch samples as given below:\n",
    "\n",
    "$$w^{IS}_i = \\left(\\frac{1}{N}.\\frac{1}{P(i)} \\right)^\\beta; \\beta=0.4$$\n",
    "\n",
    "Value of $\\beta=0.4$ has been taken from the paper cited above. \n",
    "\n",
    "While calculating the training loss, the individual TD errors $\\delta_i$ are weighed by the weights $w_i$. The updated batch loss equation is shown a few cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrioritizedReplayBuffer:\n",
    "    def __init__(self, size, alpha=0.6, beta=0.4):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to hold buffer\n",
    "        self.next_id = 0\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.priorities = np.ones(size)\n",
    "        self.epsilon = 1e-5\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        max_priority = self.priorities.max()\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.priorities[self.next_id] = max_priority\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        N = len(self.buffer)\n",
    "        priorities = self.priorities[:N]\n",
    "        probabilities = priorities ** self.alpha\n",
    "        probabilities /= probabilities.sum()\n",
    "        weights = (N * probabilities) ** (-self.beta)\n",
    "        weights /= weights.max()\n",
    "\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size, p=probabilities)\n",
    "\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        weights = weights[idxs]\n",
    "        \n",
    "        \n",
    "        return  (np.array(states), np.array(actions), np.array(rewards), \n",
    "                np.array(next_states), np.array(done_flags), np.array(weights), np.array(idxs))\n",
    "        \n",
    "    def update_priorities(self, idxs, new_priorities):\n",
    "        self.priorities[idxs] = new_priorities+self.epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for i in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset(seed=seed+i)\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN (Prioritized replay)\n",
    "\n",
    "\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation as given below. We need to modify the Loss calculation by adjusting each sample with the Importance sampling weight. \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2 . w^{IS}_i$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]. w^{IS}_i . \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_td_loss_priority_replay(agent, target_network, replay_buffer,\n",
    "                                    states, actions, rewards, next_states, done_flags, weights, buffer_idxs,\n",
    "                                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "    weights = torch.tensor(weights, device=device, dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "    \n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "    \n",
    "    #compute each sample TD error\n",
    "    loss = ((predicted_qvalues_for_actions - target_qvalues_for_actions.detach()) ** 2) * weights\n",
    "    \n",
    "    # mean squared error loss to minimize\n",
    "    loss = loss.mean()\n",
    "    \n",
    "    # calculate new priorities and update buffer\n",
    "    with torch.no_grad():\n",
    "        new_priorities = predicted_qvalues_for_actions.detach() - target_qvalues_for_actions.detach()\n",
    "        new_priorities = np.absolute(new_priorities.detach().cpu().numpy())\n",
    "        replay_buffer.update_priorities(buffer_idxs, new_priorities)\n",
    "        \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f4c20962f10>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set a seed\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Populate Experience Replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "# let us fill experience replay with some samples using full random policy\n",
    "exp_replay = PrioritizedReplayBuffer(10**4)\n",
    "for i in range(100):\n",
    "    play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "    if len(exp_replay) == 10**4:\n",
    "        break\n",
    "print(len(exp_replay))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Paramaters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 45000\n",
    "\n",
    "#init Optimizer\n",
    "opt = torch.optim.Adam(agent.parameters(), lr=1e-4)\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 20\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_rw_history = []\n",
    "td_loss_history = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Run Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 45001/45001 [05:35<00:00, 134.19it/s]\n"
     ]
    }
   ],
   "source": [
    "state, _ = env.reset(seed=seed)\n",
    "for step in trange(total_steps + 1):\n",
    "    \n",
    "    # reduce exploration as we progress\n",
    "    agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "    # take timesteps_per_epoch and update experience replay buffer\n",
    "    _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "    # train by sampling batch_size of data from experience replay\n",
    "    states, actions, rewards, next_states, done_flags, weights, idxs = exp_replay.sample(batch_size)\n",
    "    \n",
    "\n",
    "    # loss = <compute TD loss>\n",
    "    loss = compute_td_loss_priority_replay(agent, target_network, exp_replay,\n",
    "                           states, actions, rewards, next_states, done_flags, weights, idxs,              \n",
    "                           gamma=0.99,\n",
    "                           device=device)\n",
    "\n",
    "    loss.backward()\n",
    "    grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "    opt.step()\n",
    "    opt.zero_grad()\n",
    "\n",
    "    if step % loss_freq == 0:\n",
    "        td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "    if step % refresh_target_network_freq == 0:\n",
    "        # Load agent weights into target_network\n",
    "        target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "    if step % eval_freq == 0:\n",
    "        # eval the agent\n",
    "        mean_rw_history.append(evaluate(\n",
    "            make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "        )\n",
    "\n",
    "        clear_output(True)\n",
    "        print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "              (len(exp_replay), agent.epsilon))\n",
    "\n",
    "        plt.figure(figsize=[16, 5])\n",
    "        plt.subplot(1, 2, 1)\n",
    "        plt.title(\"Mean return per episode\")\n",
    "        plt.plot(mean_rw_history)\n",
    "        plt.grid()\n",
    "\n",
    "        assert not np.isnan(td_loss_history[-1])\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.title(\"TD loss history (smoothened)\")\n",
    "        plt.plot(smoothen(td_loss_history))\n",
    "        plt.grid()\n",
    "\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 1000.0\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_a/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_a/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_a/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_a/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_a/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO for readers\n",
    "\n",
    "# Try to run this on another environment of your choice from Gymnasium\n",
    "# Try to replace the training with what is available in SB3\n",
    "# Record and upload trained agent to HuggingFace\n",
    "# Add experiment logging using Weights and Biases\n",
    "# Try to do hyperparameter optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with **prioritized** experience replay and target networks. We can see that using prioritized buffer speeds up the training significantly with higher scores. This is even more evident with more complex environments like Atari games. \n",
    "\n",
    "\n",
    "We can further improve this agent with additional tricks. As we go along, we will be implementing many of these variants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
